// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({ env: cloud.DYNAMIC_CURRENT_ENV })
const db = cloud.database()
const _ = db.command

// 云函数入口函数
exports.main = async (event, context) => {
  const wxContext = cloud.getWXContext()
  const { dormId, checkData } = event
  
  try {
    // 检查参数有效性
    if (!dormId) {
      return {
        success: false,
        message: '缺少宿舍ID'
      }
    }
    
    if (!checkData || !checkData.totalScore) {
      return {
        success: false,
        message: '缺少检查数据或分数'
      }
    }
    
    // 获取宿舍信息
    const dormResult = await db.collection('dorms').doc(dormId).get()
    if (!dormResult.data) {
      return {
        success: false,
        message: '未找到对应宿舍信息'
      }
    }
    
    const dorm = dormResult.data
    const currentScore = checkData.totalScore
    
    // 更新宿舍分数，但不再更新历史记录
    const updateData = {
      currentScore: currentScore,
      lastCheckTime: new Date(),
      updateTime: new Date()
    }
    
    // 处理勋章逻辑
    // 如果分数达到90分以上，添加或保留"优秀宿舍"勋章
    if (currentScore >= 90) {
      if (!dorm.medals || !dorm.medals.includes('优秀宿舍')) {
        updateData.medals = dorm.medals || []
        if (!updateData.medals.includes('优秀宿舍')) {
          updateData.medals.push('优秀宿舍')
        }
      }
    } 
    // 如果分数低于90分，移除所有勋章
    else if (currentScore > 0 && currentScore < 90) {
      updateData.medals = []
    }
    
    // 更新宿舍信息
    await db.collection('dorms').doc(dormId).update({
      data: updateData
    })
    
    // 处理任务逻辑
    if (currentScore < 60) {
      // 检查是否已存在该宿舍的待整改或已提交任务
      const existingTasks = await db.collection('tasks').where({
        dormId: dormId,
        status: _.in(['待整改', '已提交'])
      }).get();

      if (existingTasks.data && existingTasks.data.length > 0) {
        // 如果存在，更新第一个找到的待处理任务
        const taskToUpdateId = existingTasks.data[0]._id;
        console.log(`宿舍 ${dormId} 已存在待处理任务 ${taskToUpdateId}，将进行更新。`);
        
        // 使用新的 checkData 更新任务内容
        const { taskDataForUpdate } = await prepareTaskData(checkData, wxContext.OPENID);
        await db.collection('tasks').doc(taskToUpdateId).update({
          data: {
            ...taskDataForUpdate,
            updateTime: new Date()
          }
        });
        console.log(`任务 ${taskToUpdateId} 已更新。`);
      } else {
        // 如果不存在，则创建新的整改任务
        console.log(`宿舍 ${dormId} 不存在待处理任务，将创建新任务。`);
        await createTaskInternal(checkData, wxContext.OPENID)
      }
    } else {
      // 如果分数大于等于60分，检查是否有待整改任务，如果有则标记为已整改
      await cleanupPendingTasks(dormId, currentScore, checkData.checkerId, checkData.checkerName)
    }
    
    return {
      success: true,
      message: '宿舍状态已更新',
      currentScore
    }
  } catch (error) {
    console.error('更新宿舍状态失败', error)
    return {
      success: false,
      error: error
    }
  }
}

async function prepareTaskData(checkData, openId) {
  // 生成需要整改的项目描述
  const failedItems = checkData.items.filter(item => item.score < item.maxScore * 0.6)
  let description = `本次检查总分${checkData.totalScore}分，低于及格线，需要整改以下项目：`
  let requirements = ''
  let images = []
  
  failedItems.forEach((item, index) => {
    description += `\n${index + 1}. ${item.name}：${item.score}/${item.maxScore}分`
    requirements += `${index + 1}. ${item.name}：${item.comment || '需改进'}\n`
    if (item.images && item.images.length > 0) {
      images = images.concat(item.images)
    }
  })
  
  if (images.length > 5) images = images.slice(0, 5)
  
  const deadline = new Date()
  deadline.setDate(deadline.getDate() + 3)
  
  const taskDataForUpdate = {
    dormId: checkData.dormId,
    building: checkData.building,
    roomNo: checkData.roomNo,
    roomInfo: `${checkData.building}栋${checkData.roomNo}寝室`,
    checkId: checkData._id,
    title: "需要整改寝室环境",
    description: description,
    requirements: requirements,
    images: images,
    creatorId: checkData.checkerId || openId || 'system',
    checkerName: checkData.checkerName || '系统',
    deadline: deadline,
    status: "待整改",
  };
  return { taskDataForUpdate }; 
}

// 修改后的内部创建任务函数
async function createTaskInternal(checkData, openId) {
  try {
    if (!checkData || !checkData.dormId || !checkData.building || !checkData.roomNo) {
      console.error('创建整改任务失败：缺少必要参数', checkData);
      return { success: false, error: '缺少必要参数' };
    }
    
    const { taskDataForUpdate } = await prepareTaskData(checkData, openId);
    const taskData = {
      ...taskDataForUpdate,
      createTime: new Date(), // 只有新创建时才有 createTime
      notifyStatus: ["已通知"]
    };
    
    return await db.collection('tasks').add({ data: taskData });
  } catch (error) {
    console.error('内部创建整改任务失败', error);
    throw error;
  }
}

// 清理未完成的整改任务
async function cleanupPendingTasks(dormId, score, checkerId, checkerName) {
  try {
    // 检查参数
    if (!dormId) {
      console.error('清理整改任务失败：缺少宿舍ID');
      return false;
    }
    
    // 安全设置默认值
    score = score || 60;
    checkerId = checkerId || 'system';
    checkerName = checkerName || '系统';
    
    // 使用有效的查询条件
    const validStatuses = ['待整改', '已提交'];
    const queryCondition = {
      dormId: dormId
    };
    
    // 只有当状态列表有效时才添加状态条件
    if (validStatuses && validStatuses.length > 0) {
      queryCondition.status = _.in(validStatuses);
    }
    
    const tasks = await db.collection('tasks').where(queryCondition).get();
    
    if (tasks.data && tasks.data.length > 0) {
      for (const task of tasks.data) {
        await db.collection('tasks').doc(task._id).update({
          data: {
            status: '已整改',
            updateTime: new Date(),
            completedScore: score,
            feedback: {
              content: `宿舍环境已改善，当前分数: ${score}分`,
              submitTime: new Date(),
              submitterId: checkerId,
              submitterName: checkerName
            }
          }
        })
      }
    }
    
    return true
  } catch (error) {
    console.error('清理待办任务失败', error)
    throw error
  }
} 